home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 2003 August / MW 8 2003 CD1.iso / Inside Macworld / Product News / gimp-1.2.4.sit / gimp-1.2.4 / plug-ins / helpbrowser / helpbrowser.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-07-02  |  31.0 KB  |  1,265 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * The GIMP Help Browser
  5.  * Copyright (C) 1999 Sven Neumann <sven@gimp.org>
  6.  *                    Michael Natterer <mitschel@cs.tu-berlin.de>
  7.  *
  8.  * Some code & ideas stolen from the GNOME help browser.
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23.  */
  24. #include "config.h"
  25.  
  26. #include <string.h> 
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <unistd.h>
  30.  
  31. #include <gtk/gtk.h>
  32. #include <gdk/gdkkeysyms.h>
  33. #include <gtk-xmhtml/gtk-xmhtml.h>
  34.  
  35. #include <libgimp/gimp.h>
  36. #include <libgimp/gimpui.h>
  37.  
  38. #include "queue.h"
  39.  
  40. #include "libgimp/stdplugins-intl.h"
  41.  
  42. #include "forward.xpm"
  43. #include "back.xpm"
  44.  
  45.  
  46. /*  defines  */
  47.  
  48. #ifdef __EMX__
  49. #define chdir _chdir2
  50. #endif
  51.  
  52. #define GIMP_HELP_EXT_NAME      "extension_gimp_help_browser"
  53. #define GIMP_HELP_TEMP_EXT_NAME "extension_gimp_help_browser_temp"
  54.  
  55. #define GIMP_HELP_PREFIX        "help"
  56.  
  57. enum {
  58.   CONTENTS,
  59.   INDEX,
  60.   HELP
  61. };
  62.  
  63. enum {
  64.   URL_UNKNOWN,
  65.   URL_NAMED, /* ??? */
  66.   URL_JUMP,
  67.   URL_FILE_LOCAL,
  68.  
  69.   /* aliases */
  70.   URL_LAST = URL_FILE_LOCAL
  71. };
  72.  
  73. /*  structures  */
  74.  
  75. typedef struct 
  76. {
  77.   gint       index;
  78.   gchar     *label;
  79.   Queue     *queue;
  80.   gchar     *current_ref;
  81.   GtkWidget *html;
  82.   gchar     *home;
  83. } HelpPage;
  84.  
  85. typedef struct
  86. {
  87.   gchar *title;
  88.   gchar *ref;
  89.   gint   count;
  90. } HistoryItem;
  91.  
  92. /*  constant strings  */
  93.  
  94. static gchar *doc_not_found_format_string =
  95. N_("<html><head><title>Document not found</title></head>"
  96.    "<body bgcolor=\"#ffffff\">"
  97.    "<center>"
  98.    "<p>"
  99.    "%s"
  100.    "<h3>Couldn't find document</h3>"
  101.    "<tt>%s</tt>"
  102.    "</center>"
  103.    "<p>"
  104.    "<small>This either means that the help for this topic has not been written "
  105.    "yet or that something is wrong with your installation. "
  106.    "Please check carefully before you report this as a bug.</small>" 
  107.    "</body>"
  108.    "</html>");
  109.  
  110. static gchar *dir_not_found_format_string =
  111. N_("<html><head><title>Directory not found</title></head>"
  112.    "<body bgcolor=\"#ffffff\">"
  113.    "<center>"
  114.    "<p>"
  115.    "%s"
  116.    "<h3>Couldn't change to directory</h3>"
  117.    "<tt>%s</tt>"
  118.    "<h3>while trying to access</h3>"
  119.    "<tt>%s</tt>"
  120.    "</center>"
  121.    "<p>"
  122.    "<small>This either means that the help for this topic has not been written "
  123.    "yet or that something is wrong with your installation. "
  124.    "Please check carefully before you report this as a bug.</small>" 
  125.    "</body>"
  126.    "</html>");
  127.  
  128. static gchar *eek_png_tag = "<h1>Eeek!</h1>";
  129.  
  130.  
  131. /*  the three help notebook pages  */
  132.  
  133. static HelpPage pages[] =
  134. {
  135.   {
  136.     CONTENTS,
  137.     N_("Contents"),
  138.     NULL,
  139.     NULL,
  140.     NULL,
  141.     "contents.html"
  142.   },
  143.  
  144.   {
  145.     INDEX,
  146.     N_("Index"),
  147.     NULL,
  148.     NULL,
  149.     NULL,
  150.     "index.html"
  151.   },
  152.  
  153.   {
  154.     HELP,
  155.     NULL,
  156.     NULL,
  157.     NULL,
  158.     NULL,
  159.     "introduction.html"
  160.   }
  161. };
  162.  
  163. static gchar     *gimp_help_root = NULL;
  164.  
  165. static HelpPage  *current_page = &pages[HELP];
  166. static GList     *history = NULL;
  167.  
  168. static GtkWidget *back_button;
  169. static GtkWidget *forward_button;
  170. static GtkWidget *notebook;
  171. static GtkWidget *combo;
  172.  
  173. static GtkTargetEntry help_dnd_target_table[] =
  174. {
  175.   { "_NETSCAPE_URL", 0, 0 },
  176. };
  177. static guint n_help_dnd_targets = (sizeof (help_dnd_target_table) /
  178.                    sizeof (help_dnd_target_table[0]));
  179.  
  180. /*  GIMP plugin stuff  */
  181.  
  182. static void query (void);
  183. static void run   (gchar      *name,
  184.            gint        nparams,
  185.            GimpParam  *param,
  186.            gint       *nreturn_vals,
  187.            GimpParam **return_vals);
  188.  
  189. GimpPlugInInfo PLUG_IN_INFO =
  190. {
  191.   NULL,  /* init_proc  */
  192.   NULL,  /* quit_proc  */
  193.   query, /* query_proc */
  194.   run,   /* run_proc   */
  195. };
  196.  
  197. static gboolean temp_proc_installed = FALSE;
  198.  
  199. /*  forward declaration  */
  200.  
  201. static gint load_page (HelpPage *source_page,
  202.                HelpPage *dest_page,
  203.                gchar    *ref,
  204.                gint      pos, 
  205.                gboolean  add_to_queue,
  206.                gboolean  add_to_history);
  207.  
  208. /*  functions  */
  209.  
  210. static void
  211. close_callback (GtkWidget *widget,
  212.         gpointer   user_data)
  213. {
  214.   gtk_main_quit ();
  215. }
  216.  
  217. static void
  218. update_toolbar (HelpPage *page)
  219. {
  220.   if (back_button)
  221.     gtk_widget_set_sensitive (back_button, queue_isprev (page->queue));
  222.   if (forward_button)
  223.     gtk_widget_set_sensitive (forward_button, queue_isnext (page->queue));
  224. }
  225.  
  226. static void
  227. jump_to_anchor (HelpPage *page, 
  228.         gchar    *anchor)
  229. {
  230.   gint pos;
  231.  
  232.   g_return_if_fail (page != NULL && anchor != NULL);
  233.  
  234.   if (*anchor != '#') 
  235.     {
  236.       gchar *a = g_strconcat ("#", anchor, NULL);
  237.       XmHTMLAnchorScrollToName (page->html, a);
  238.       g_free (a);
  239.     }
  240.   else
  241.     XmHTMLAnchorScrollToName (page->html, anchor);
  242.  
  243.   pos = gtk_xmhtml_get_topline (GTK_XMHTML (page->html));
  244.   queue_add (page->queue, page->current_ref, pos);
  245.  
  246.   update_toolbar (page);
  247. }
  248.  
  249. static void
  250. forward_callback (GtkWidget *widget,
  251.           gpointer   data)
  252. {
  253.   gchar *ref;
  254.   gint pos;
  255.  
  256.   if (!(ref = queue_next (current_page->queue, &pos)))
  257.     return;
  258.  
  259.   load_page (current_page, current_page, ref, pos, FALSE, FALSE);
  260.   queue_move_next (current_page->queue);
  261.  
  262.   update_toolbar (current_page);
  263. }
  264.  
  265. static void
  266. back_callback (GtkWidget *widget,
  267.            gpointer   data)
  268. {
  269.   gchar *ref;
  270.   gint pos;
  271.  
  272.   if (!(ref = queue_prev (current_page->queue, &pos)))
  273.     return;
  274.  
  275.   load_page (current_page, current_page, ref, pos, FALSE, FALSE);
  276.   queue_move_prev (current_page->queue);
  277.  
  278.   update_toolbar (current_page);
  279. }
  280.  
  281. static void 
  282. entry_changed_callback (GtkWidget *widget,
  283.             gpointer   data)
  284. {
  285.   GList       *list;
  286.   HistoryItem *item;
  287.   gchar       *entry_text;
  288.   gchar       *compare_text;
  289.   gboolean     found = FALSE;
  290.  
  291.   entry_text = gtk_entry_get_text (GTK_ENTRY (widget));
  292.  
  293.   for (list = history; list && !found; list = list->next)
  294.     {
  295.       item = (HistoryItem *) list->data;
  296.  
  297.       if (item->count)
  298.     compare_text = g_strdup_printf ("%s <%i>",
  299.                     item->title,
  300.                     item->count + 1);
  301.       else
  302.     compare_text = item->title;
  303.  
  304.       if (strcmp (compare_text, entry_text) == 0)
  305.     {
  306.       load_page (&pages[HELP], &pages[HELP], item->ref, 0, TRUE, FALSE);
  307.       found = TRUE;
  308.     }
  309.  
  310.       if (item->count)
  311.     g_free (compare_text);
  312.     }
  313. }
  314.  
  315. static gint
  316. entry_button_press_callback (GtkWidget      *widget,
  317.                  GdkEventButton *bevent,
  318.                  gpointer        data)
  319. {
  320.   if (current_page != &pages[HELP])
  321.     gtk_notebook_set_page (GTK_NOTEBOOK (notebook), HELP);
  322.  
  323.   return FALSE;
  324. }
  325.  
  326. static void
  327. history_add (gchar *ref,
  328.          gchar *title)
  329. {
  330.   GList       *list;
  331.   GList       *found = NULL;
  332.   HistoryItem *item;
  333.   GList       *combo_list = NULL;
  334.   gint         title_found_count = 0;
  335.  
  336.   for (list = history; list && !found; list = list->next)
  337.     {
  338.       item = (HistoryItem *) list->data;
  339.  
  340.       if (strcmp (item->title, title) == 0)
  341.     {
  342.       if (strcmp (item->ref, ref) != 0)
  343.         {
  344.           title_found_count++;
  345.           continue;
  346.         }
  347.  
  348.       found = list;    }
  349.     }
  350.  
  351.   if (found)
  352.     {
  353.       item = (HistoryItem *) found->data;
  354.       history = g_list_remove_link (history, found);
  355.     }
  356.   else
  357.     {
  358.       item = g_new (HistoryItem, 1);
  359.       item->ref = g_strdup (ref);
  360.       item->title = g_strdup (title);
  361.       item->count = title_found_count;
  362.     }
  363.  
  364.   history = g_list_prepend (history, item);
  365.  
  366.   for (list = history; list; list = list->next)
  367.     {
  368.       gchar* combo_title;
  369.  
  370.       item = (HistoryItem *) list->data;
  371.  
  372.       if (item->count)
  373.     combo_title = g_strdup_printf ("%s <%i>",
  374.                        item->title,
  375.                        item->count + 1);
  376.       else
  377.     combo_title = g_strdup (item->title);
  378.  
  379.       combo_list = g_list_prepend (combo_list, combo_title);
  380.     }
  381.  
  382.   combo_list = g_list_reverse (combo_list);
  383.  
  384.   gtk_signal_handler_block_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry), combo);
  385.   gtk_combo_set_popdown_strings (GTK_COMBO (combo), combo_list);
  386. /*    gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), item->title); */
  387.   gtk_signal_handler_unblock_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry), combo);
  388.  
  389.   for (list = combo_list; list; list = list->next)
  390.     g_free (list->data);
  391.  
  392.   g_list_free (combo_list);
  393. }
  394.  
  395. static void
  396. html_source (HelpPage *page,
  397.          gchar    *ref,
  398.          gint      pos,
  399.          gchar    *source, 
  400.          gboolean  add_to_queue,
  401.          gboolean  add_to_history)
  402. {
  403.   gchar *title = NULL;
  404.   
  405.   g_return_if_fail (page != NULL && ref != NULL && source != NULL);
  406.   
  407.   /* Load it up */
  408.   gtk_xmhtml_source (GTK_XMHTML (page->html), source);
  409.   
  410.   gtk_xmhtml_set_topline (GTK_XMHTML(page->html), pos);
  411.   
  412.   if (add_to_queue) 
  413.     queue_add (page->queue, ref, pos);
  414.  
  415.   if (page->index == HELP)
  416.     {
  417.       title = XmHTMLGetTitle (page->html);
  418.       if (!title)
  419.     title = (_("<Untitled>"));
  420.       
  421.       if (add_to_history)
  422.     history_add (ref, title);
  423.  
  424.       gtk_signal_handler_block_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry),
  425.                     combo);
  426.       gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), title);
  427.       gtk_signal_handler_unblock_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry),
  428.                       combo);
  429.     }
  430.  
  431.   update_toolbar (page);
  432. }
  433.  
  434. static gint
  435. load_page (HelpPage *source_page,
  436.        HelpPage *dest_page,
  437.        gchar    *ref,      
  438.        gint      pos,
  439.        gboolean  add_to_queue,
  440.        gboolean  add_to_history)
  441. {
  442.   GString  *file_contents;
  443.   FILE     *afile = NULL;
  444.   gchar     aline[1024];
  445.   gchar    *old_dir;
  446.   gchar    *new_dir, *new_base;
  447.   gchar    *new_ref;
  448.   gchar    *anchor;
  449.   gboolean  page_valid  = FALSE;
  450.  
  451.   g_return_val_if_fail (ref != NULL &&  
  452.                         source_page != NULL && dest_page != NULL, FALSE);
  453.  
  454.   old_dir  = g_dirname (source_page->current_ref);
  455.   new_dir  = g_dirname (ref);
  456.   new_base = g_basename (ref);
  457.  
  458.   /* return value is intentionally ignored */
  459.   chdir (old_dir);
  460.  
  461.   file_contents = g_string_new (NULL);
  462.  
  463.   if (chdir (new_dir) == -1)
  464.     {
  465.       if (g_path_is_absolute (ref))
  466.     new_ref = g_strdup (ref);
  467.       else
  468.     new_ref = g_strconcat (old_dir, G_DIR_SEPARATOR_S, ref, NULL);
  469.  
  470.       g_string_sprintf (file_contents, gettext (dir_not_found_format_string),
  471.             eek_png_tag, new_dir, new_ref);
  472.       html_source (dest_page, new_ref, 0, file_contents->str, add_to_queue, FALSE);
  473.  
  474.       goto FINISH;
  475.     }
  476.  
  477.   g_free (new_dir);
  478.   new_dir = g_get_current_dir ();
  479.  
  480.   new_ref = g_strconcat (new_dir, G_DIR_SEPARATOR_S, new_base, NULL);
  481.  
  482.   if (strcmp (dest_page->current_ref, new_ref) == 0)
  483.     {
  484.       gtk_xmhtml_set_topline (GTK_XMHTML (dest_page->html), pos);
  485.  
  486.       if (add_to_queue)
  487.     queue_add (dest_page->queue, new_ref, pos);
  488.  
  489.       goto FINISH;
  490.     }
  491.  
  492.   /*
  493.    *  handle basename like: filename.html#11111 -> filename.html
  494.    */
  495.   anchor = strchr (new_base, '#');
  496.   if (anchor)
  497.     {
  498.       *anchor = '\0';
  499.       anchor++;
  500.     }
  501.  
  502.   afile = fopen (new_base, "rt");
  503.  
  504.   if (afile != NULL)
  505.     {
  506.       while (fgets (aline, sizeof (aline), afile))
  507.     file_contents = g_string_append (file_contents, aline);
  508.       fclose (afile);
  509.     }
  510.  
  511.   if (strlen (file_contents->str) <= 0)
  512.     {
  513.       chdir (old_dir);
  514.       g_string_sprintf (file_contents, gettext (doc_not_found_format_string),
  515.             eek_png_tag, ref);
  516.     }
  517.   else
  518.     page_valid = TRUE;
  519.  
  520.   html_source (dest_page, new_ref, 0, file_contents->str, 
  521.            add_to_queue, add_to_history && page_valid);
  522.  
  523.   if (anchor)
  524.     jump_to_anchor (current_page, anchor);
  525.  
  526.  FINISH:
  527.  
  528.   g_free (dest_page->current_ref);
  529.   dest_page->current_ref = new_ref;
  530.  
  531.   g_string_free (file_contents, TRUE);
  532.   g_free (old_dir);
  533.   g_free (new_dir);
  534.  
  535.   gtk_notebook_set_page (GTK_NOTEBOOK (notebook), dest_page->index);
  536.  
  537.   return (page_valid);
  538. }
  539.  
  540. static void
  541. xmhtml_activate (GtkWidget *html,
  542.          gpointer   data)
  543. {
  544.   XmHTMLAnchorCallbackStruct *cbs = (XmHTMLAnchorCallbackStruct *) data;
  545.   GimpParam *return_vals;
  546.   gint       nreturn_vals;
  547.  
  548.   switch (cbs->url_type)
  549.     {
  550.     case URL_JUMP:
  551.       jump_to_anchor (current_page, cbs->href);
  552.       break;
  553.  
  554.     case URL_FILE_LOCAL:
  555.       load_page (current_page, &pages[HELP], cbs->href, 0, TRUE, TRUE);
  556.       break;
  557.  
  558.     default:
  559.       /*  try to call netscape through the web_browser interface */
  560.       return_vals = gimp_run_procedure ("extension_web_browser",
  561.                     &nreturn_vals,
  562.                     GIMP_PDB_INT32,  GIMP_RUN_NONINTERACTIVE,
  563.                     GIMP_PDB_STRING, cbs->href,
  564.                     GIMP_PDB_INT32,  FALSE,
  565.                     GIMP_PDB_END);
  566.        gimp_destroy_params (return_vals, nreturn_vals);
  567.       break;
  568.     }
  569. }
  570.  
  571. static void 
  572. notebook_switch_callback (GtkNotebook     *notebook,
  573.               GtkNotebookPage *page,
  574.               gint             page_num,
  575.               gpointer         user_data)
  576. {
  577.   GtkXmHTML *html;
  578.   gint       i;
  579.   GList     *children;
  580.  
  581.   g_return_if_fail (page_num >= 0 && page_num < 3);
  582.  
  583.   html = GTK_XMHTML (current_page->html);
  584.  
  585.   /*  The html widget fails to do the following by itself  */
  586.  
  587.   GTK_WIDGET_UNSET_FLAGS (html->html.work_area, GTK_MAPPED);
  588.   GTK_WIDGET_UNSET_FLAGS (html->html.vsb, GTK_MAPPED);
  589.   GTK_WIDGET_UNSET_FLAGS (html->html.hsb, GTK_MAPPED);
  590.  
  591.   /*  Frames  */
  592.   for (i = 0; i < html->html.nframes; i++)
  593.     GTK_WIDGET_UNSET_FLAGS (html->html.frames[i]->frame, GTK_MAPPED);
  594.  
  595.   /*  Form widgets  */
  596.   for (children = html->children; children; children = children->next)
  597.     GTK_WIDGET_UNSET_FLAGS (children->data, GTK_MAPPED);
  598.  
  599.   /*  Set the new page  */
  600.   current_page = &pages[page_num];
  601. }
  602.  
  603. static void 
  604. notebook_switch_after_callback (GtkNotebook     *notebook,
  605.                 GtkNotebookPage *page,
  606.                 gint             page_num,
  607.                 gpointer         user_data)
  608. {
  609.   GtkAccelGroup *accel_group = gtk_accel_group_get_default ();
  610.  
  611.   gtk_widget_add_accelerator (GTK_XMHTML (current_page->html)->html.vsb,
  612.                   "page_up", accel_group,
  613.                   'b', 0, 0);
  614.   gtk_widget_add_accelerator (GTK_XMHTML (current_page->html)->html.vsb,
  615.                   "page_down", accel_group,
  616.                   ' ', 0, 0);
  617.  
  618.   gtk_widget_add_accelerator (GTK_XMHTML (current_page->html)->html.vsb,
  619.                   "page_up", accel_group,
  620.                   GDK_Page_Up, 0, 0);
  621.   gtk_widget_add_accelerator (GTK_XMHTML (current_page->html)->html.vsb,
  622.                   "page_down", accel_group,
  623.                   GDK_Page_Down, 0, 0);
  624.  
  625.   update_toolbar (current_page);
  626. }
  627.  
  628.  
  629. static gint
  630. notebook_label_button_press_callback (GtkWidget *widget,
  631.                       GdkEvent  *event,
  632.                       gpointer   data)
  633. {
  634.   guint i = GPOINTER_TO_UINT (data);
  635.  
  636.   if (current_page != &pages[i])
  637.     gtk_notebook_set_page (GTK_NOTEBOOK (notebook), i);
  638.   
  639.   return TRUE;
  640. }
  641.  
  642. static void
  643. combo_drag_begin (GtkWidget *widget,
  644.           gpointer   data)
  645. { 
  646. }
  647.  
  648. static void
  649. combo_drag_handle (GtkWidget        *widget, 
  650.            GdkDragContext   *context,
  651.            GtkSelectionData *selection_data,
  652.            guint             info,
  653.            guint             time,
  654.            gpointer          data)
  655. {
  656.   HelpPage *page = (HelpPage*)data;
  657.  
  658.   if (page->current_ref != NULL)
  659.     {
  660.       gtk_selection_data_set (selection_data,
  661.                   selection_data->target,
  662.                   8, 
  663.                   page->current_ref, 
  664.                   strlen (page->current_ref));
  665.     }
  666. }
  667.  
  668. static void
  669. page_up_callback (GtkWidget *widget,
  670.           GtkWidget *html)
  671. {
  672.   GtkAdjustment *adj;
  673.  
  674.   adj = GTK_ADJUSTMENT (GTK_XMHTML (html)->vsba);
  675.   gtk_adjustment_set_value (adj, adj->value - (adj->page_size));
  676. }
  677.  
  678. static void
  679. page_down_callback (GtkWidget *widget,
  680.             GtkWidget *html)
  681. {
  682.   GtkAdjustment *adj;
  683.  
  684.   adj = GTK_ADJUSTMENT (GTK_XMHTML (html)->vsba);
  685.   gtk_adjustment_set_value (adj, adj->value + (adj->page_size));
  686. }
  687.  
  688. static gint
  689. wheel_callback (GtkWidget      *widget,
  690.         GdkEventButton *bevent,
  691.         GtkWidget      *html)
  692. {
  693.   GtkAdjustment *adj;
  694.   gfloat new_value;
  695.  
  696.   if (! GTK_XMHTML (html)->html.needs_vsb)
  697.     return FALSE;
  698.  
  699.   adj = GTK_ADJUSTMENT (GTK_XMHTML (html)->vsba);
  700.  
  701.   switch (bevent->button)
  702.     {
  703.     case 4:
  704.       new_value = adj->value - adj->page_increment / 2;
  705.       break;
  706.  
  707.     case 5:
  708.       new_value = adj->value + adj->page_increment / 2;
  709.       break;
  710.  
  711.     default:
  712.       return FALSE;
  713.     }
  714.  
  715.   new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
  716.   gtk_adjustment_set_value (adj, new_value);
  717.  
  718.   return TRUE;
  719. }
  720.  
  721. static gint
  722. set_initial_history (gpointer data)
  723. {
  724.   gint   add_to_history = GPOINTER_TO_INT (data);
  725.   gchar *title;
  726.  
  727.   title = XmHTMLGetTitle (pages[HELP].html);
  728.   if (add_to_history)
  729.     history_add (pages[HELP].current_ref, title);
  730.  
  731.   gtk_signal_handler_block_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry), combo);
  732.   gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), title);
  733.   gtk_signal_handler_unblock_by_data (GTK_OBJECT (GTK_COMBO (combo)->entry), combo);
  734.  
  735.   return FALSE;
  736. }
  737.  
  738. gboolean
  739. open_browser_dialog (gchar *help_path,
  740.              gchar *locale,
  741.              gchar *help_file)
  742. {
  743.   GtkWidget *window;
  744.   GtkWidget *vbox, *hbox, *bbox, *html_box;
  745.   GtkWidget *button;
  746.   GtkWidget *title;
  747.   GtkWidget *drag_source;
  748.   GtkWidget *label;
  749.  
  750.   gchar   *initial_dir;
  751.   gchar   *initial_ref;
  752.   gchar   *root_dir;
  753.   gchar   *eek_png_path;
  754.   gint     success;
  755.   guint    i;
  756.  
  757.   gimp_ui_init ("helpbrowser", TRUE);
  758.  
  759.   root_dir = g_strdup (gimp_help_root);
  760.  
  761.   if (chdir (root_dir) == -1)
  762.     {
  763.       g_message (_("GIMP Help Browser Error.\n\n"
  764.            "Couldn't find my root html directory.\n"
  765.            "(%s)"), root_dir);
  766.       return FALSE;
  767.     }
  768.  
  769.   eek_png_path = g_strconcat (root_dir, G_DIR_SEPARATOR_S,
  770.                   "images", G_DIR_SEPARATOR_S,
  771.                   "eek.png", NULL);
  772.   if (access (eek_png_path, R_OK) == 0)
  773.     eek_png_tag = g_strdup_printf ("<img src=\"%s\">", eek_png_path);
  774.  
  775.   g_free (eek_png_path);
  776.  
  777.   if (chdir (help_path) == -1)
  778.     {
  779.       g_message (_("GIMP Help Browser Error.\n\n"
  780.            "Couldn't find my root html directory.\n"
  781.            "(%s)"), help_path);
  782.       return FALSE;
  783.     }
  784.  
  785.   initial_dir = g_get_current_dir ();
  786.  
  787.   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  788.   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
  789.               GTK_SIGNAL_FUNC (close_callback),
  790.               NULL);
  791.   gtk_signal_connect (GTK_OBJECT (window), "destroy",
  792.               GTK_SIGNAL_FUNC (close_callback),
  793.               NULL);
  794.   gtk_window_set_wmclass (GTK_WINDOW (window), "helpbrowser", "Gimp");
  795.   gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser"));
  796.  
  797.   gimp_help_connect_help_accel (window, gimp_standard_help_func,
  798.                 "dialogs/help.html");
  799.  
  800.   vbox = gtk_vbox_new (FALSE, 0);
  801.   gtk_container_add (GTK_CONTAINER (window), vbox);
  802.  
  803.   hbox = gtk_hbox_new (FALSE, 0);
  804.   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  805.  
  806.   bbox = gtk_hbutton_box_new ();
  807.   gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), 0);
  808.   gtk_box_pack_start (GTK_BOX (hbox), bbox, FALSE, FALSE, 0);
  809.  
  810.   back_button = gimp_pixmap_button_new (back_xpm, _("Back"));
  811.   gtk_button_set_relief (GTK_BUTTON (back_button), GTK_RELIEF_NONE);
  812.   gtk_container_add (GTK_CONTAINER (bbox), back_button);
  813.   gtk_widget_set_sensitive (GTK_WIDGET (back_button), FALSE);
  814.   gtk_signal_connect (GTK_OBJECT (back_button), "clicked",
  815.               GTK_SIGNAL_FUNC (back_callback),
  816.               NULL);
  817.   gtk_widget_show (back_button);
  818.  
  819.   forward_button = gimp_pixmap_button_new (forward_xpm, _("Forward"));
  820.   gtk_button_set_relief (GTK_BUTTON (forward_button), GTK_RELIEF_NONE);
  821.   gtk_container_add (GTK_CONTAINER (bbox), forward_button);
  822.   gtk_widget_set_sensitive (GTK_WIDGET (forward_button), FALSE);
  823.   gtk_signal_connect (GTK_OBJECT (forward_button), "clicked",
  824.               GTK_SIGNAL_FUNC (forward_callback),
  825.               NULL);
  826.   gtk_widget_show (forward_button);
  827.  
  828.   gtk_widget_show (bbox);
  829.  
  830.   bbox = gtk_hbutton_box_new ();
  831.   gtk_box_pack_end (GTK_BOX (hbox), bbox, FALSE, FALSE, 0);
  832.  
  833.   button = gtk_button_new_with_label (_("Close"));
  834.   gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
  835.   gtk_container_add (GTK_CONTAINER (bbox), button);
  836.   gtk_signal_connect (GTK_OBJECT (button), "clicked",
  837.                GTK_SIGNAL_FUNC (close_callback),
  838.               NULL);
  839.   gtk_widget_show (button);
  840.  
  841.   gtk_widget_show (bbox);
  842.   gtk_widget_show (hbox);
  843.  
  844.   notebook = gtk_notebook_new ();
  845.   gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
  846.   gtk_notebook_set_tab_vborder (GTK_NOTEBOOK (notebook), 0);
  847.   gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
  848.  
  849.   for (i = 0; i < 3; i++)
  850.     {
  851.       static guint page_up_signal = 0;
  852.       static guint page_down_signal = 0;
  853.  
  854.       pages[i].index       = i;
  855.       pages[i].html        = gtk_xmhtml_new ();
  856.       pages[i].queue       = queue_new ();
  857.  
  858.       gtk_xmhtml_set_anchor_underline_type (GTK_XMHTML (pages[i].html),
  859.                         GTK_ANCHOR_SINGLE_LINE);
  860.       gtk_xmhtml_set_anchor_buttons (GTK_XMHTML (pages[i].html), FALSE);
  861.       gtk_widget_set_usize (GTK_WIDGET (pages[i].html), -1, 300);
  862.  
  863.       switch (i)
  864.     {
  865.     case CONTENTS:
  866.     case INDEX:
  867.       pages[i].current_ref = g_strconcat (root_dir, G_DIR_SEPARATOR_S,
  868.                           locale, G_DIR_SEPARATOR_S,
  869.                           ".", NULL);
  870.  
  871.       title = drag_source = gtk_event_box_new ();
  872.       label = gtk_label_new (gettext (pages[i].label));
  873.       gtk_container_add (GTK_CONTAINER (title), label);
  874.       gtk_widget_show (label);
  875.       break;
  876.     case HELP:
  877.       pages[i].current_ref = g_strconcat (initial_dir, G_DIR_SEPARATOR_S,
  878.                           locale, G_DIR_SEPARATOR_S,
  879.                           ".", NULL);
  880.  
  881.       title = combo = gtk_combo_new ();
  882.       drag_source = GTK_COMBO (combo)->entry;
  883.       gtk_widget_set_usize (GTK_WIDGET (combo), 300, -1);
  884.       gtk_entry_set_editable (GTK_ENTRY (GTK_COMBO (combo)->entry), FALSE); 
  885.       gtk_combo_set_use_arrows (GTK_COMBO (combo), TRUE);
  886.       gtk_signal_connect (GTK_OBJECT (GTK_COMBO (combo)->entry), 
  887.                   "changed",
  888.                   GTK_SIGNAL_FUNC (entry_changed_callback), 
  889.                   combo);
  890.       gtk_signal_connect (GTK_OBJECT (GTK_WIDGET (GTK_COMBO (combo)->entry)), 
  891.                   "button-press-event",
  892.                   GTK_SIGNAL_FUNC (entry_button_press_callback), 
  893.                   NULL);
  894.       gtk_widget_show (combo);
  895.       break;
  896.     default:
  897.       title = drag_source = NULL;     /* to please the compiler */
  898.       break;
  899.     }      
  900.  
  901.       /*  connect to the button_press signal to make notebook switching work */ 
  902.       gtk_signal_connect (GTK_OBJECT (title), "button_press_event",
  903.               GTK_SIGNAL_FUNC (notebook_label_button_press_callback), 
  904.               GUINT_TO_POINTER (i));
  905.  
  906.       /*  dnd source  */
  907.       gtk_drag_source_set (GTK_WIDGET (drag_source),
  908.                GDK_BUTTON1_MASK,
  909.                help_dnd_target_table, n_help_dnd_targets, 
  910.                GDK_ACTION_MOVE | GDK_ACTION_COPY);
  911.       gtk_signal_connect (GTK_OBJECT (drag_source), "drag_begin",
  912.               GTK_SIGNAL_FUNC (combo_drag_begin),
  913.               &pages[i]);
  914.       gtk_signal_connect (GTK_OBJECT (drag_source), "drag_data_get",
  915.               GTK_SIGNAL_FUNC (combo_drag_handle),
  916.               &pages[i]);
  917.  
  918.       html_box = gtk_vbox_new (FALSE, 0);
  919.       gtk_container_add (GTK_CONTAINER (html_box), pages[i].html);
  920.  
  921.       gtk_notebook_append_page (GTK_NOTEBOOK (notebook), html_box, title);
  922.       gtk_widget_show (title);
  923.  
  924.       if (i == HELP && help_file)
  925.     {
  926.       initial_ref = g_strconcat (initial_dir, G_DIR_SEPARATOR_S,
  927.                      locale, G_DIR_SEPARATOR_S,
  928.                      help_file, NULL);
  929.     }
  930.       else
  931.     {
  932.       initial_ref = g_strconcat (root_dir, G_DIR_SEPARATOR_S,
  933.                      locale, G_DIR_SEPARATOR_S,
  934.                      pages[i].home, NULL);
  935.     }
  936.  
  937.       success = load_page (&pages[i], &pages[i], initial_ref, 0, TRUE, FALSE);
  938.       g_free (initial_ref);
  939.  
  940.       gtk_widget_show (pages[i].html);
  941.       gtk_widget_show (html_box);
  942.       gtk_signal_connect (GTK_OBJECT (pages[i].html), "activate",
  943.               (GtkSignalFunc) xmhtml_activate,
  944.               &pages[i]);
  945.  
  946.       if (! page_up_signal)
  947.     {
  948.       page_up_signal = gtk_object_class_user_signal_new 
  949.         (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.vsb)->klass,
  950.          "page_up",
  951.          GTK_RUN_FIRST,
  952.          gtk_marshal_NONE__NONE,
  953.          GTK_TYPE_NONE, 0);
  954.       page_down_signal = gtk_object_class_user_signal_new
  955.         (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.vsb)->klass,
  956.          "page_down",
  957.          GTK_RUN_FIRST,
  958.          gtk_marshal_NONE__NONE,
  959.          GTK_TYPE_NONE, 0);
  960.     }
  961.  
  962.       gtk_signal_connect (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.vsb),
  963.               "page_up",
  964.               GTK_SIGNAL_FUNC (page_up_callback),
  965.               pages[i].html);
  966.       gtk_signal_connect (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.vsb), 
  967.               "page_down",
  968.               GTK_SIGNAL_FUNC (page_down_callback),
  969.               pages[i].html);
  970.  
  971.       gtk_signal_connect (GTK_OBJECT (GTK_XMHTML (pages[i].html)->html.work_area),
  972.               "button_press_event",
  973.               GTK_SIGNAL_FUNC (wheel_callback),
  974.               pages[i].html);
  975.     }
  976.  
  977.   g_free (root_dir);
  978.  
  979.   gtk_signal_connect (GTK_OBJECT (notebook), "switch-page",
  980.               GTK_SIGNAL_FUNC (notebook_switch_callback),
  981.               NULL);
  982.   gtk_signal_connect_after (GTK_OBJECT (notebook), "switch-page",
  983.                 GTK_SIGNAL_FUNC (notebook_switch_after_callback),
  984.                 NULL);
  985.  
  986.   gtk_notebook_set_page (GTK_NOTEBOOK (notebook), HELP);
  987.   gtk_widget_show (notebook);
  988.  
  989.   gtk_widget_show (vbox);
  990.   gtk_widget_show (window);
  991.  
  992.   gtk_idle_add ((GtkFunction) set_initial_history, GINT_TO_POINTER (success));
  993.  
  994.   g_free (initial_dir);
  995.  
  996.   return TRUE;
  997. }
  998.  
  999. static gint
  1000. idle_load_page (gpointer data)
  1001. {
  1002.   gchar *path = data;
  1003.  
  1004.   load_page (&pages[HELP], &pages[HELP], path, 0, TRUE, TRUE);
  1005.   g_free (path);
  1006.  
  1007.   return FALSE;
  1008. }
  1009.  
  1010. static void
  1011. run_temp_proc (gchar      *name,
  1012.            gint        nparams,
  1013.            GimpParam  *param,
  1014.            gint       *nreturn_vals,
  1015.            GimpParam **return_vals)
  1016. {
  1017.   static GimpParam  values[1];
  1018.   GimpPDBStatusType status = GIMP_PDB_SUCCESS;
  1019.   gchar *help_path;
  1020.   gchar *locale;
  1021.   gchar *help_file;
  1022.   gchar *path;
  1023.  
  1024.   /*  set default values  */
  1025.   help_path = g_strdup (gimp_help_root);
  1026.   locale    = g_strdup ("C");
  1027.   help_file = g_strdup ("introduction.html");
  1028.  
  1029.   /*  Make sure all the arguments are there!  */
  1030.   if (nparams == 3)
  1031.     {
  1032.       if (param[0].data.d_string && strlen (param[0].data.d_string))
  1033.     {
  1034.       g_free (help_path);
  1035.       help_path = g_strdup (param[0].data.d_string);
  1036.       g_strdelimit (help_path, "/", G_DIR_SEPARATOR);
  1037.     }
  1038.       if (param[1].data.d_string && strlen (param[1].data.d_string))
  1039.     {
  1040.       g_free (locale);
  1041.       locale    = g_strdup (param[1].data.d_string);
  1042.     }
  1043.       if (param[2].data.d_string && strlen (param[2].data.d_string))
  1044.     {
  1045.       g_free (help_file);
  1046.       help_file = g_strdup (param[2].data.d_string);
  1047.       g_strdelimit (help_file, "/", G_DIR_SEPARATOR);
  1048.     }
  1049.     }
  1050.  
  1051.   path = g_strconcat (help_path, G_DIR_SEPARATOR_S, 
  1052.               locale, G_DIR_SEPARATOR_S,
  1053.               help_file, NULL);
  1054.  
  1055.   g_free (help_path);
  1056.   g_free (locale);
  1057.   g_free (help_file);
  1058.  
  1059.   gtk_idle_add (idle_load_page, path);
  1060.  
  1061.   *nreturn_vals = 1;
  1062.   *return_vals = values;
  1063.  
  1064.   values[0].type = GIMP_PDB_STATUS;
  1065.   values[0].data.d_status = status;
  1066. }
  1067.  
  1068. /*  from libgimp/gimp.c  */
  1069. void
  1070. gimp_run_temp (void);
  1071.  
  1072. static gboolean
  1073. input_callback (GIOChannel   *channel,
  1074.                 GIOCondition  condition,
  1075.                 gpointer      data)
  1076. {
  1077.   /* We have some data in the wire - read it */
  1078.   /* The below will only ever run a single proc */
  1079.   gimp_run_temp ();
  1080.  
  1081.   return TRUE;
  1082. }
  1083.  
  1084. static void
  1085. install_temp_proc (void)
  1086. {
  1087.   static GimpParamDef args[] =
  1088.   {
  1089.     { GIMP_PDB_STRING, "help_path", "" },
  1090.     { GIMP_PDB_STRING, "locale",    "Langusge to use" },
  1091.     { GIMP_PDB_STRING, "help_file", "Path of a local document to open. "
  1092.                                     "Can be relative to GIMP_HELP_PATH." }
  1093.   };
  1094.   static gint nargs = sizeof (args) / sizeof (args[0]);
  1095.  
  1096.   gimp_install_temp_proc (GIMP_HELP_TEMP_EXT_NAME,
  1097.               "DON'T USE THIS ONE",
  1098.               "(Temporary procedure)",
  1099.               "Sven Neumann <sven@gimp.org>, "
  1100.               "Michael Natterer <mitschel@cs.tu-berlin.de>",
  1101.               "Sven Neumann & Michael Natterer",
  1102.               "1999",
  1103.               NULL,
  1104.               "",
  1105.               GIMP_TEMPORARY,
  1106.               nargs, 0,
  1107.               args, NULL,
  1108.               run_temp_proc);
  1109.  
  1110.   /* Tie into the gdk input function */
  1111.   g_io_add_watch (_readchannel, G_IO_IN | G_IO_PRI, input_callback, NULL);
  1112.  
  1113.   temp_proc_installed = TRUE;
  1114. }
  1115.  
  1116. static gboolean
  1117. open_url (gchar *help_path,
  1118.       gchar *locale,
  1119.       gchar *help_file)
  1120. {
  1121.   if (! open_browser_dialog (help_path, locale, help_file))
  1122.     return FALSE;
  1123.  
  1124.   install_temp_proc ();
  1125.   gtk_main ();
  1126.  
  1127.   return TRUE;
  1128. }
  1129.  
  1130. MAIN ()
  1131.  
  1132. static void
  1133. query (void)
  1134. {
  1135.   static GimpParamDef args[] =
  1136.   {
  1137.     { GIMP_PDB_INT32,  "run_mode",  "Interactive" },
  1138.     { GIMP_PDB_STRING, "help_path", "" },
  1139.     { GIMP_PDB_STRING, "locale",    "Language to use" },
  1140.     { GIMP_PDB_STRING, "help_file", "Path of a local document to open. "
  1141.                                     "Can be relative to GIMP_HELP_PATH." }
  1142.   };
  1143.   static gint nargs = sizeof (args) / sizeof (args[0]);
  1144.  
  1145.   gimp_install_procedure (GIMP_HELP_EXT_NAME,
  1146.                           "Browse the GIMP help pages",
  1147.                           "A small and simple HTML browser optimzed for "
  1148.               "browsing the GIMP help pages.",
  1149.                           "Sven Neumann <sven@gimp.org>, "
  1150.               "Michael Natterer <mitch@gimp.org>",
  1151.               "Sven Neumann & Michael Natterer",
  1152.                           "1999",
  1153.                           NULL,
  1154.                           "",
  1155.                           GIMP_EXTENSION,
  1156.                           nargs, 0,
  1157.                           args, NULL);
  1158. }
  1159.  
  1160. static void
  1161. run (gchar      *name,
  1162.      gint        nparams,
  1163.      GimpParam  *param,
  1164.      gint       *nreturn_vals,
  1165.      GimpParam **return_vals)
  1166. {
  1167.   static GimpParam  values[1];
  1168.   GimpRunModeType   run_mode;
  1169.   GimpPDBStatusType status = GIMP_PDB_SUCCESS;
  1170.   gchar *env_root_dir = NULL;
  1171.   gchar *help_path    = NULL;
  1172.   gchar *locale       = NULL;
  1173.   gchar *help_file    = NULL;
  1174.  
  1175.   run_mode = param[0].data.d_int32;
  1176.  
  1177.   values[0].type = GIMP_PDB_STATUS;
  1178.   values[0].data.d_status = status;
  1179.  
  1180.   *nreturn_vals = 1;
  1181.   *return_vals = values;
  1182.  
  1183.   INIT_I18N_UI ();
  1184.  
  1185.   if (strcmp (name, GIMP_HELP_EXT_NAME) == 0)
  1186.     {
  1187.       switch (run_mode)
  1188.         {
  1189.         case GIMP_RUN_INTERACTIVE:
  1190.         case GIMP_RUN_NONINTERACTIVE:
  1191.     case GIMP_RUN_WITH_LAST_VALS:
  1192.       /*  set default values  */
  1193.       env_root_dir = g_getenv ("GIMP_HELP_ROOT");
  1194.  
  1195.       if (env_root_dir)
  1196.         {
  1197.           if (chdir (env_root_dir) == -1)
  1198.         {
  1199.           g_message (_("GIMP Help Browser Error.\n\n"
  1200.                    "Couldn't find GIMP_HELP_ROOT html directory.\n"
  1201.                    "(%s)"), env_root_dir);
  1202.  
  1203.           status = GIMP_PDB_EXECUTION_ERROR;
  1204.           break;
  1205.         }
  1206.  
  1207.           gimp_help_root = g_strdup (env_root_dir);
  1208.         }
  1209.       else
  1210.         {
  1211.           gimp_help_root = g_strconcat (gimp_data_directory(),
  1212.                         G_DIR_SEPARATOR_S, 
  1213.                         GIMP_HELP_PREFIX, NULL);
  1214.         }
  1215.  
  1216.       help_path = g_strdup (gimp_help_root);
  1217.       locale    = g_strdup ("C");
  1218.       help_file = g_strdup ("introduction.html");
  1219.       
  1220.       /*  Make sure all the arguments are there!  */
  1221.       if (nparams == 4)
  1222.         {
  1223.           if (param[1].data.d_string && strlen (param[1].data.d_string))
  1224.         {
  1225.           g_free (help_path);
  1226.           help_path = g_strdup (param[1].data.d_string);
  1227.           g_strdelimit (help_path, "/", G_DIR_SEPARATOR);
  1228.         }
  1229.           if (param[2].data.d_string && strlen (param[2].data.d_string))
  1230.         {
  1231.           g_free (locale);
  1232.           locale = g_strdup (param[2].data.d_string);
  1233.         }
  1234.           if (param[3].data.d_string && strlen (param[3].data.d_string))
  1235.         {
  1236.           g_free (help_file);
  1237.           help_file = g_strdup (param[3].data.d_string);
  1238.           g_strdelimit (help_file, "/", G_DIR_SEPARATOR);
  1239.         }
  1240.         }
  1241.           break;
  1242.  
  1243.         default:
  1244.       status = GIMP_PDB_CALLING_ERROR;
  1245.           break;
  1246.         }
  1247.  
  1248.       if (status == GIMP_PDB_SUCCESS)
  1249.         {
  1250.              if (!open_url (help_path, locale, help_file))
  1251.             values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
  1252.       else
  1253.         values[0].data.d_status = GIMP_PDB_SUCCESS;
  1254.  
  1255.       g_free (help_path);
  1256.       g_free (locale);
  1257.       g_free (help_file);
  1258.         }
  1259.       else
  1260.         values[0].data.d_status = status;
  1261.     }
  1262.   else
  1263.     values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
  1264. }
  1265.